Reusing expression graphs in computer programming languages

ABSTRACT

A reusable expression graph system and method that generates reusable expression graphs that can be used with potentially different input parameters in order to achieve computational efficiency and ease of programming. Reusable expression graph mitigate the need to rebuild an expression for each new value. This is achieved in part by creating a node called a “parameter node.” The parameter node acts as a generic placeholder for a leaf node in the expression graph. In addition, the parameter node acts as a proxy for a bindable term of the leaf node, and the bindable term can be either a value or one or more additional expressions. The parameter node then is bound to the bindable term and the expression is evaluated with that bindable term instead of the placeholder. The parameter node created by embodiments of the reusable expression graph system and method works across many different programming languages.

BACKGROUND

Software developers often use functions when coding software programs. Afunction is a portion of code within a larger program that performsparticular assignment and is relatively independent of the remainder ofthe code. Functions allow a developer to divide a program into sectionsso that those sections can be reused throughout the program fordifferent value without the need to rewrite the program each time thevalues are changed.

In general, a function accepts a parameter as input, processes theparameter according to the function, and then returns a result. Aparameter is a generic placeholder that acts as a proxy until an actualvalue is assigned to the parameter. Once the actual value is assigned tothe parameter then the expression is evaluated with the assigned valuerather than the placeholder.

Software developers also may use of expressions, which are a combinationof functions and values. Software developers often build up expressionswhen they are writing programs. Based on rules of precedence andassociation for the particular programming language being used, anexpression is computed and a value or answer is returned. This processof computing and returning a value for an expression is known as“evaluating the expression.”

One way in which expressions are represented so that they can beevaluated is by using expression graphs. An expression graph is adirected acyclic graph having nodes and edges. The nodes are values andoperators that are connected to each other by edges. For example, assumea simple expression is created that is (A+B)*C. In order to build anexpression graph for this expression nodes are created for “A,” “B,” and“C” and nodes “A” and “B” are connected by a “+” node. Moreover, a nodeis created for “*” and that node is placed above the “+” node and a lineis drawn down to the “+” node and a line down to C. This is anexpression graph representing the expression (A+B)*C.

Expression graphs include both operator nodes and leaf nodes. A leafnode (or external node) is a node of an expression graph that contains avalue. In addition, the leaf node has zero child nodes or other nodeshanging off of them. An operator node is a node in the expression graphthat performs an operation (such as addition or multiplication) on thevalues in the leaf nodes. In the above example, the “+” node and the “*”node are operator nodes, and the values “A,” “B,” and “C” nodes are leafnodes.

SUMMARY

This Summary is provided to introduce a selection of concepts in asimplified form that are further described below in the DetailedDescription. This Summary is not intended to identify key features oressential features of the claimed subject matter, nor is it intended tobe used to limit the scope of the claimed subject matter.

Embodiments of the reusable expression graph system and method reuseexpression graphs with potentially different input parameters in orderto achieve computational efficiency and ease of programming. In asimilar way that functions allow a programmer to reuse code, embodimentsof the reusable expression graph system and method allow expressiongraphs (and thereby expressions) to be reused without the need torebuild the expression for each new value.

Embodiments of the reusable expression graph system and method include anode called a “parameter node.” This parameter node is a leaf node thatcan be bound to any expression node, including other leaf nodes. Thus,the parameter node is a leaf node that is a generic placeholder.Moreover, the parameter node is placeholder that is not restricted toleaf nodes but other types of nodes as well. The parameter node can actas a proxy for a bindable term of the leaf node, and the bindable termcan be either a value or one or more additional expressions. Theparameter node then is bound to the bindable term and the expression isevaluated with that bindable term rather than the placeholder.

Embodiments of the reusable expression graph system and method mitigatethe instances of a developer having to rebuild an entire expression eachtime they wanted to change the value of a leaf node. In other words, thedeveloper does not have to run the code to rebuild the expression everytime the value of a leaf node is changed. Moreover, the parameter nodecreated by embodiments of the reusable expression graph system andmethod works across many different types of programming languages.

It should be noted that alternative embodiments are possible, and thatsteps and elements discussed herein may be changed, added, oreliminated, depending on the particular embodiment. These alternativeembodiments include alternative steps and alternative elements that maybe used, and structural changes that may be made, without departing fromthe scope of the invention.

DRAWINGS DESCRIPTION

Referring now to the drawings in which like reference numbers representcorresponding parts throughout:

FIG. 1 illustrates an example of a standard expression graph 100representing an expression c=a+b.

FIG. 2 is a detailed flow diagram illustrating the operational detailsof the generation of a parameter node for embodiments of the reusableexpression graph method.

FIG. 3 illustrates an example of a reusable expression graph having afirst parameter node “A”.

FIG. 4 illustrates an example of a reusable expression graph having thefirst parameter node “A” and a second parameter node “B”.

FIG. 5 illustrates an example of a reusable expression graph having asecond parameter node “A”, the second leaf node, and joined by theoperator node.

FIG. 6 illustrates an example of a reusable expression graph having thefirst parameter node “A”, a third parameter node “B”, and joined by theoperator node.

FIG. 7 is a flow diagram illustrating the operation of embodiments ofthe reusable expression graph system and method shown in FIGS. 2-6.

FIG. 8 illustrates an example of a suitable computing system environmentin which embodiments of the reusable expression graph system and methodshown in FIGS. 2-7 may be implemented.

DETAILED DESCRIPTION

In the following description of embodiments of the reusable expressiongraph system and method reference is made to the accompanying drawings,which form a part thereof, and in which is shown by way of illustrationa specific example whereby embodiments of the reusable expression graphsystem and method may be practiced. It is to be understood that otherembodiments may be utilized and structural changes may be made withoutdeparting from the scope of the claimed subject matter.

I. Overview

Embodiments of the reusable expression graph system and method build andevaluate expressions represented by expression graphs. FIG. 1illustrates an example of a standard expression graph 100 representingthe expression c=a+b. As shown in FIG. 1, the standard expression graph100 includes a first node 110 containing the hard value “a,” and asecond node 120 containing the hard value “b.” The first node 110 andthe second node 120 are joined by an operator node 130 representing theaddition operator. Note that in this example the “+” sign is an operatorand the value “a” and the value “b” are operands.

For all of the reasons that functions are used in programming languages,it is also desirable to also use functions in embodiments of thereusable expression graph system and method. Just as functions allow aprogrammer to reuse code, embodiments of the reusable expression graphsystem and method facilitate the reuse of expressions represented byexpression graphs. In a standard programming language a function uses aparameter as a generic placeholder. Thus, each time the function isreused all that is necessary is for the programmer to give a value tothe placeholder and then the function will be evaluated with that valueinstead of the placeholder. Embodiments of the reusable expression graphsystem and method use this idea of a placeholder and apply it toexpression graphs to make the expression graph reusable.

II. Operational Details

The operational details of embodiments of the reusable expression graphsystem and method now will be discussed.

II.A. Parameter Node

Embodiments of the reusable expression graph system and method createand use a node called a “parameter node.” The parameter node allows anexpression graph to be reused. A parameter node is a generic placeholderin an expression graph that allows for a bindable term to be used inplace of the parameter node when the expression is evaluated. Thebindable term can be a hard value, another expression, another parameternode, or any combination thereof. The bindable term is bound to theparameter node and the expression is evaluated using that bindable term.

Moreover, the expression can be reevaluated with a different bindableterm bound to the parameter node. In other words, if a user builds anexpression that contains a parameter node as a leaf, the expression canbe reused with different values (or bindings) for the parameter. Theadvantages of embodiments of the reusable expression graph system andmethod is that a developer does not have to rebuild the entireexpression every time they wanted to change the value of a leaf node ofthe expression graph representing that expression. In other words,embodiments of the reusable expression graph system and method alleviatethe developer having to run the code to rebuild the expression everytime the value of an expression graph leaf node is changed. Reuse notonly saves building the expression, but also allows the reuse of some ofthe evaluation of the expression. For example in the case whereexpressions are used to generate code, parameter nodes allow thegenerated code to be saved and reused for different parameter bindings.In addition, expression graphs can be embedded in various languagesthrough libraries. Parameter nodes used by embodiments of the reusableexpression graph system and method allow the reuse of these expressiongraphs and can be used in any programming language in which theexpression graph can be used.

The parameter node is a special kind of leaf node. In the example aboveshown in FIG. 1, the user could use a parameter node in place of thesecond leaf node 120. The parameter node allows a user to set the valueof the parameter node to different values whenever she wants to evaluatethe expression. Those different values are used in place of thatparameter node each time the expression is evaluated. In someembodiments of the reusable expression graph system and method, theparameter node has a “type,” meaning that it can be specified whetherthe parameter node takes a floating point value or an integer value. Inalternate embodiments of the reusable expression graph system andmethod, the value of the parameter node can have any type.

The parameter node also allows the expression to be reused, withouthaving to build up the expression again just to change a value (such asthe second leaf node 120 shown in FIG. 1). Embodiments of the reusableexpression graph system and method allow expression graphs to be builtup. In effect the expression graphs are functional. The value at theparameter node can be changed easily without rebuilding the expression.Moreover, each time the user adds a node to the expression this createsa new expression, while the old expression included in the newexpression does not change. This is not true of standard non-functionalprogramming languages. Moreover, embodiments of the reusable expressiongraph system and method can be easily embedded in virtually anyprogramming language.

II.B. Generating a Parameter Node

FIG. 2 is a detailed flow diagram illustrating the operational detailsof the generation of a parameter node for embodiments of the reusableexpression graph method. In general, a parameter node is generated orcreated by a user when building an expression to make the expressiongraph reusable. More specifically, as shown in FIG. 2, embodiments ofthe reusable expression graph method allow a user to select a parameternode when an expression is being built (box 200). Typically, thisselection is done by a user, although in some embodiments it may beperformed automatically.

Next, embodiments of the reusable expression graph method create anexpression graph containing the parameter node (box 210). As notedabove, this parameter node acts as a generic placeholder on theexpression graph. FIG. 3 illustrates an example of a reusable expressiongraph 300 having a first parameter node, P1 310. By comparing FIG. 3with FIG. 1, it can be seen that first parameter node, P1310 is usedinstead of the first node 110. In addition, the operator node 130 stilljoins the first parameter node P1 310 and the second node 120. Thisreusable expression graph 300 represents the expression c=P1+b, where P1is represented by the first parameter node, P1 310 and b is representedby the second node 120.

Embodiments of the reusable expression graph system and method alsoallow the use of as many parameter nodes as there are leaf nodes in anexpression graph. FIG. 4 illustrates an example of a reusable expressiongraph 400 having the first parameter node, P1 310 and a second parameternode, P2 410. The first parameter node, P1310 and the second parameternode P2 410 are joined by the operator node 130. The reusable expressiongraph 400 in this case represents the expression given by c=P1+P2, whereagain P1 is represented by the first parameter node P1 310 and P2 isrepresented by the second parameter node, P2 410.

Referring back to FIG. 2, a decision then is made (typically by theuser) on how to bind the parameter node (box 220). In general, theparameter node can be bound to virtually anything. In some embodimentsthe user selects what values or expressions to bind to the parameternode. The parameter node does not have to be bound to a leaf value. Theparameter can be bound to a leaf, which would be a hard value, or atwo-dimensional array, or it can be bound to another expression in theform of another directed acyclic graph. One way in which the parameternode can be bound is to a single hard value (boxes 230). By “hard value”it is meant a value that is a constant. The value may a single value ora multi-dimensional array of values. For example, a single hard valuemay be the number “8”, while one-dimensional arrays of numbers andtwo-dimensional arrays of numbers may also be used and included in thephrase “hard value.”

Another way in which the parameter node can be bound is to bind theparameter node to an expression that contains a plurality of hard values(box 240). FIG. 5 illustrates an example of a reusable expression graph500 having a third parameter node, P3 510, the second node 120, andjoined by the operator node 130. The reusable expression graph 500 inthis case represents the expression given by c=P3+b, where P3 isrepresented by the third parameter node, P3 510 and b is represented bythe second node 120. In this example shown in FIG. 5, P3=(a*b). Thismeans that the third parameter node, P3510 is bound to an expressionthat contains a plurality of hard values, or (a*b).

Still another way in which the parameter node can be bound is to bindthe parameter node to an expression that contains an embedded parameter(box 250). FIG. 6 illustrates an example of a reusable expression graph600 having the first parameter node, P1 310, a fourth parameter node, P4610, and joined by the operator node 130. The reusable expression graph600 in this case represents the expression given by c=P1+P4, where P1 isrepresented by the first parameter node, P1 310 and P4 is represented bythe fourth parameter node, P4 610. In this example shown in FIG. 6, theparameter node contains another parameter node. In particular,P4=(a*P5). This means that the fourth parameter node, P4 610 is bound toan expression that contains an embedded parameter node, or (a*P5). Oncethe parameter node is bound in the selected manner, embodiments of thereusable expression graph method output the bound parameter node (box260).

II.C. Using the Parameter Node

Embodiments of the reusable expression graph system and method not onlycreate or generate the parameter node as a replacement for a leaf node,but also use the parameter node to obtain a reusable expression graph.FIG. 7 is a flow diagram illustrating the operation of embodiments ofthe reusable expression graph system and method shown in FIGS. 2-6. Ingeneral, embodiments of the reusable expression graph system and methodcreate a parameter node for an expression graph and use the parameternode in evaluating the expression represented by the expression graph.In particular, referring to FIG. 7, the method begins by creating orgenerating a parameter node (box 700). This process of generating theparameter node is described in above in the discussion about FIG. 2.Next, a user generates an expression using the parameter node (box 710).This expression can be represented by an expression graph, and theexpression graph contains the parameter node.

Embodiments of the reusable expression graph system and method then bindthe parameter node to a first bindable term (box 720). The expressionthen is evaluated using the first bindable term in place of theparameter node (box 730). In this way the expression graph is reusablebecause the expression behaves like a function. The values currentlybound are the parameters with which the expression is evaluated.

The expression graph then is reused by binding the parameter node to asecond bindable term (box 740). The expression then is evaluated usingthe second bindable term (box 750). In this manner, the reusableexpression graph can be reused by binding different values to theparameter node. The expression then can be evaluated without the need torebuild the expression each time the value is changed.

III. Exemplary Operating Environment

Embodiments of the reusable expression graph system and method aredesigned to operate in a computing environment. The following discussionis intended to provide a brief, general description of a suitablecomputing environment in which embodiments of the reusable expressiongraph system and method may be implemented.

FIG. 8 illustrates an example of a suitable computing system environmentin which embodiments of the reusable expression graph system and methodshown in FIGS. 2-7 may be implemented. The computing system environment800 is only one example of a suitable computing environment and is notintended to suggest any limitation as to the scope of use orfunctionality of the invention. Neither should the computing environment800 be interpreted as having any dependency or requirement relating toany one or combination of components illustrated in the exemplaryoperating environment.

Embodiments of the reusable expression graph system and method areoperational with numerous other general purpose or special purposecomputing system environments or configurations. Examples of well knowncomputing systems, environments, and/or configurations that may besuitable for use with embodiments of the reusable expression graphsystem and method include, but are not limited to, personal computers,server computers, hand-held (including smartphones), laptop or mobilecomputer or communications devices such as cell phones and PDA's,multiprocessor systems, microprocessor-based systems, set top boxes,programmable consumer electronics, network PCs, minicomputers, mainframecomputers, distributed computing environments that include any of theabove systems or devices, and the like.

Embodiments of the reusable expression graph system and method may bedescribed in the general context of computer-executable instructions,such as program modules, being executed by a computer. Generally,program modules include routines, programs, objects, components, datastructures, etc., that perform particular tasks or implement particularabstract data types. Embodiments of the reusable expression graph systemand method may also be practiced in distributed computing environmentswhere tasks are performed by remote processing devices that are linkedthrough a communications network. In a distributed computingenvironment, program modules may be located in both local and remotecomputer storage media including memory storage devices. Still further,the aforementioned instructions may be implemented, in part or in whole,as hardware logic circuits, which may or may not include a processor.With reference to FIG. 8, an exemplary system for embodiments of thereusable expression graph system and method includes a general-purposecomputing device in the form of a computer 810.

Components of the computer 810 may include, but are not limited to, aprocessing unit 820 (such as a central processing unit, CPU), a systemmemory 830, and a system bus 821 that couples various system componentsincluding the system memory to the processing unit 820. The system bus821 may be any of several types of bus structures including a memory busor memory controller, a peripheral bus, and a local bus using any of avariety of bus architectures. By way of example, and not limitation,such architectures include Industry Standard Architecture (ISA) bus,Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, VideoElectronics Standards Association (VESA) local bus, and PeripheralComponent Interconnect (PCI) bus also known as Mezzanine bus.

The computer 810 typically includes a variety of computer readablemedia. Computer readable media can be any available media that can beaccessed by the computer 810 and includes both volatile and nonvolatilemedia, removable and non-removable media. By way of example, and notlimitation, computer readable media may comprise computer storage mediaand communication media. Computer storage media includes volatile andnonvolatile removable and non-removable media implemented in any methodor technology for storage of information such as computer readableinstructions, data structures, program modules or other data.

Computer storage media includes, but is not limited to, RAM, ROM,EEPROM, flash memory or other memory technology, CD-ROM, digitalversatile disks (DVD) or other optical disk storage, magnetic cassettes,magnetic tape, magnetic disk storage or other magnetic storage devices,or any other medium which can be used to store the desired informationand which can be accessed by the computer 810. By way of example, andnot limitation, communication media includes wired media such as a wirednetwork or direct-wired connection, and wireless media such as acoustic,RF, infrared and other wireless media. Combinations of any of the aboveshould also be included within the scope of computer readable media.

The system memory 830 includes computer storage media in the form ofvolatile and/or nonvolatile memory such as read only memory (ROM) 831and random access memory (RAM) 832. A basic input/output system 833(BIOS), containing the basic routines that help to transfer informationbetween elements within the computer 810, such as during start-up, istypically stored in ROM 831. RAM 832 typically contains data and/orprogram modules that are immediately accessible to and/or presentlybeing operated on by processing unit 820. By way of example, and notlimitation, FIG. 8 illustrates operating system 834, applicationprograms 835, other program modules 836, and program data 837.

The computer 810 may also include other removable/non-removable,volatile/nonvolatile computer storage media. By way of example only,FIG. 8 illustrates a hard disk drive 841 that reads from or writes tonon-removable, nonvolatile magnetic media, a magnetic disk drive 851that reads from or writes to a removable, nonvolatile magnetic disk 852,and an optical disk drive 855 that reads from or writes to a removable,nonvolatile optical disk 856 such as a CD ROM or other optical media.

Other removable/non-removable, volatile/nonvolatile computer storagemedia that can be used in the exemplary operating environment include,but are not limited to, magnetic tape cassettes, flash memory cards,digital versatile disks, digital video tape, solid state RAM, solidstate ROM, and the like. The hard disk drive 841 is typically connectedto the system bus 821 through a non-removable memory interface such asinterface 840, and magnetic disk drive 851 and optical disk drive 855are typically connected to the system bus 821 by a removable memoryinterface, such as interface 850.

The drives and their associated computer storage media discussed aboveand illustrated in FIG. 8, provide storage of computer readableinstructions, data structures, program modules and other data for thecomputer 810. In FIG. 8, for example, hard disk drive 841 is illustratedas storing operating system 844, application programs 845, other programmodules 846, and program data 847. Note that these components can eitherbe the same as or different from operating system 834, applicationprograms 835, other program modules 836, and program data 837. Operatingsystem 844, application programs 845, other program modules 846, andprogram data 847 are given different numbers here to illustrate that, ata minimum, they are different copies. A user may enter commands andinformation (or data) into the computer 810 through input devices suchas a keyboard 862, pointing device 861, commonly referred to as a mouse,trackball or touch pad, and a touch panel or touch screen (not shown).

Other input devices (not shown) may include a microphone, joystick, gamepad, satellite dish, scanner, radio receiver, or a television orbroadcast video receiver, or the like. These and other input devices areoften connected to the processing unit 820 through a user inputinterface 860 that is coupled to the system bus 821, but may beconnected by other interface and bus structures, such as, for example, aparallel port, game port or a universal serial bus (USB). A monitor 891or other type of display device is also connected to the system bus 821via an interface, such as a video interface 890. In addition to themonitor, computers may also include other peripheral output devices suchas speakers 897 and printer 896, which may be connected through anoutput peripheral interface 895.

The computer 810 may operate in a networked environment using logicalconnections to one or more remote computers, such as a remote computer880. The remote computer 880 may be a personal computer, a server, arouter, a network PC, a peer device or other common network node, andtypically includes many or all of the elements described above relativeto the computer 810, although only a memory storage device 881 has beenillustrated in FIG. 8. The logical connections depicted in FIG. 8include a local area network (LAN) 871 and a wide area network (WAN)873, but may also include other networks. Such networking environmentsare commonplace in offices, enterprise-wide computer networks, intranetsand the Internet.

When used in a LAN networking environment, the computer 810 is connectedto the LAN 871 through a network interface or adapter 870. When used ina WAN networking environment, the computer 810 typically includes amodem 872 or other means for establishing communications over the WAN873, such as the Internet. The modem 872, which may be internal orexternal, may be connected to the system bus 821 via the user inputinterface 860, or other appropriate mechanism. In a networkedenvironment, program modules depicted relative to the computer 810, orportions thereof, may be stored in the remote memory storage device. Byway of example, and not limitation, FIG. 8 illustrates remoteapplication programs 885 as residing on memory device 881. It will beappreciated that the network connections shown are exemplary and othermeans of establishing a communications link between the computers may beused.

The foregoing Detailed Description has been presented for the purposesof illustration and description. Many modifications and variations arepossible in light of the above teaching. It is not intended to beexhaustive or to limit the subject matter described herein to theprecise form disclosed. Although the subject matter has been describedin language specific to structural features and/or methodological acts,it is to be understood that the subject matter defined in the appendedclaims is not necessarily limited to the specific features or actsdescribed above. Rather, the specific features and acts described aboveare disclosed as example forms of implementing the claims appendedhereto.

What is claimed is:
 1. A computing system comprising: a processing unit;and one or more computer storage media having computer readableinstructions stored thereon that, when executed by the processing unit,cause the processing unit to: build a reusable expression graph using aparameter node as a leaf node that acts as a placeholder, wherein thereusable expression graph represents an expression; bind the parameternode to a bindable term such that the parameter node acts act as a proxyfor the bindable term, the bindable term comprising another expressionthat contains a plurality of hard values; and evaluate the expressionusing the bindable term comprising the another expression that containsthe plurality of hard values.
 2. The computing system of claim 1,wherein the computer readable instructions further cause the processingunit to: receive a user input selecting the another expression, and bindthe parameter node to the bindable term comprising the anotherexpression responsive to the user input.
 3. The computing system ofclaim 1, wherein the computer readable instructions further cause theprocessing unit to: reuse the reusable expression graph by: binding theparameter node to another bindable term comprising a single hard value,and reevaluating the expression with the parameter node bound to theanother bindable term comprising the single hard value withoutrebuilding the expression.
 4. The computing system of claim 1, whereinthe computer readable instructions further cause the processing unit to:reuse the reusable expression graph by: binding the parameter node toanother bindable term comprising a further expression, and reevaluatingthe expression using the further expression instead of the anotherexpression without rebuilding the expression.
 5. The computing system ofclaim 4, wherein the further expression comprises multiple hard valuesthat are different than the plurality of hard values of the anotherexpression.
 6. The computing system of claim 1, wherein the anotherexpression comprises a directed acyclic graph.
 7. One or morecomputer-readable memory devices or storage devices storing computerreadable instructions which, when executed by a processing unit of acomputing device, cause the processing unit to perform acts comprising:building a reusable expression graph using a parameter node as a leafnode that acts as a placeholder, wherein the reusable expression graphrepresents a first expression; binding the parameter node to a bindableterm comprising a second expression that contains an embedded parameter;and evaluating the first expression using the bindable term comprisingthe second expression that contains the embedded parameter.
 8. The oneor more computer-readable memory devices or storage devices of claim 7,wherein the reusable expression graph comprises another parameter nodecorresponding to the embedded parameter.
 9. The one or morecomputer-readable memory devices or storage devices of claim 7, the actsfurther comprising: reusing the reusable expression graph by: bindingthe parameter node to another bindable term comprising a thirdexpression, and evaluating the first expression using the thirdexpression instead of the second expression without rebuilding anentirety of the first expression.
 10. The one or more computer-readablememory devices or storage devices of claim 9, wherein the thirdexpression contains another embedded parameter.
 11. The one or morecomputer-readable memory devices or storage devices of claim 9, whereinthe third expression contains a hard value and does not contain anotherembedded parameter.
 12. The one or more computer-readable memory devicesor storage devices of claim 9, wherein the third expression contains aplurality of hard values.
 13. The one or more computer-readable memorydevices or storage devices of claim 7, wherein the parameter node has anassociated data type indicating the parameter node takes an integervalue.
 14. The one or more computer-readable memory devices or storagedevices of claim 7, wherein the parameter node has an associated datatype indicating the parameter node takes a floating point value.
 15. Acomputer-readable memory device or storage device storing a reusableexpression graph, the reusable expression graph comprising: an operatornode containing an operator; a first parameter node that acts as a firstplaceholder; and a second parameter node that is joined to the firstparameter node by the operator node, wherein the first parameter nodecomprises at least one operator and at least one operand.
 16. Thecomputer-readable memory device or storage device of claim 15, furtherstoring computer readable instructions which, when executed by aprocessing unit of a computing device, cause the processing unit toperform acts comprising: evaluating an expression represented by thereusable expression graph, including evaluating the at least oneoperator and the at least one operand.
 17. The computer-readable memorydevice or storage device of claim 16, the reusable expression graphfurther comprising a third parameter node.
 18. The computer-readablememory device or storage device of claim 17, wherein the third parameternode further comprises a fourth parameter node.
 19. Thecomputer-readable memory device or storage device of claim 18, whereinthe third parameter node further comprises another operator and thefourth parameter node is another operand.
 20. The computer-readablememory device or storage device of claim 15, further storing computerreadable instructions which, when executed by a processing unit of acomputing device, cause the processing unit to perform acts comprising:at a first time, evaluating an expression represented by the reusableexpression graph by evaluating the at least one operator and the atleast one operand; binding the first parameter node to a differentoperator and a different operand; and at a second time, evaluating theexpression represented by the reusable expression graph by evaluatingthe different operator and the different operand instead of the at leastone operator and the at least one operand without rebuilding an entiretyof the expression.